home *** CD-ROM | disk | FTP | other *** search
/ Aminet 16 / Aminet 16 (1996)(GTI - Schatztruhe)[!][Dec 1996].iso / Aminet / comm / term / term_source.lha / Extras / Source / term-source.lha / AmigaGuide.c < prev    next >
C/C++ Source or Header  |  1996-10-20  |  8KB  |  374 lines
  1. /*
  2. **    AmigaGuide.c
  3. **
  4. **    AmigaGuide support routines
  5. **
  6. **    Copyright © 1990-1993 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. **
  9. **    :ts=4
  10. */
  11.  
  12. #ifndef _GLOBAL_H
  13. #include "Global.h"
  14. #endif
  15.  
  16.     /* Local data. */
  17.  
  18. STATIC STRPTR                 ContextList[55];
  19. STATIC AMIGAGUIDECONTEXT     Context;
  20. STATIC struct NewAmigaGuide     NewGuide;
  21. STATIC struct Process        *GuideProcess;
  22. STATIC LONG                     GuideContextID = CONTEXT_MAIN;
  23.  
  24.     /* GuideServer(VOID):
  25.      *
  26.      *    AmigaGuide server, handles all the signal processing.
  27.      */
  28.  
  29. STATIC VOID SAVE_DS
  30. GuideServer(VOID)
  31. {
  32.         /* Open the help text file asynchronously... */
  33.  
  34.     if(Context = OpenAmigaGuideAsync(&NewGuide,TAG_DONE))
  35.     {
  36.         ULONG GuideMask,Signals;
  37.         BOOL Done = FALSE;
  38.  
  39.             /* Pick up the signal notification mask. */
  40.  
  41.         GuideMask = AmigaGuideSignal(Context);
  42.  
  43.             /* Clear the context stack. */
  44.  
  45.         SetAmigaGuideContext(Context,0,TAG_DONE);
  46.  
  47.             /* Flag the main process to continue. */
  48.  
  49.         Signal((struct Task *)ThisProcess,SIG_HANDSHAKE);
  50.  
  51.             /* Go into input loop. */
  52.  
  53.         do
  54.         {
  55.                 /* Wait for a signal... */
  56.  
  57.             Signals = Wait(SIG_KILL | GuideMask);
  58.  
  59.                 /* Are we to quit? */
  60.  
  61.             if(Signals & SIG_KILL)
  62.                 Done = TRUE;
  63.  
  64.                 /* Process icoming AmigaGuide messages. */
  65.  
  66.             if(Signals & GuideMask)
  67.             {
  68.                 struct AmigaGuideMsg *GuideMessage;
  69.  
  70.                 while(GuideMessage = GetAmigaGuideMsg(Context))
  71.                     ReplyAmigaGuideMsg(GuideMessage);
  72.             }
  73.         }
  74.         while(!Done);
  75.  
  76.             /* Close the help text file. */
  77.  
  78.         CloseAmigaGuide(Context);
  79.     }
  80.  
  81.         /* Lock & quit. */
  82.  
  83.     Forbid();
  84.  
  85.     GuideProcess = NULL;
  86.  
  87.     Signal((struct Task *)ThisProcess,SIG_HANDSHAKE);
  88. }
  89.  
  90.     /* GuideLaunch(LONG ContextID):
  91.      *
  92.      *    Launch the AmigaGuide help file server.
  93.      */
  94.  
  95. STATIC BOOL
  96. GuideLaunch(LONG ContextID)
  97. {
  98.         /* Is the main program running and is this the
  99.          * main program to make the call?
  100.          */
  101.  
  102.     if(Window && FindTask(NULL) == (struct Task *)ThisProcess)
  103.     {
  104.             /* Is the help file server already running? */
  105.  
  106.         if(!GuideProcess)
  107.         {
  108.             if(!AmigaGuideBase)
  109.                 AmigaGuideBase = OpenLibrary("amigaguide.library",0);
  110.  
  111.             if(AmigaGuideBase)
  112.             {
  113.                 BOOL IsValidFile = TRUE;
  114.  
  115.                     /* Do we have a valid AmigaGuide file name? */
  116.  
  117.                 if(Config->PathConfig->HelpFile[0])
  118.                 {
  119.                     if(!GetFileSize(Config->PathConfig->HelpFile))
  120.                         IsValidFile = FALSE;
  121.                 }
  122.                 else
  123.                     IsValidFile = FALSE;
  124.  
  125.                     /* Do we have a valid AmigaGuide file name? */
  126.  
  127.                 if(!IsValidFile)
  128.                 {
  129.                         /* Don't pop up the file requester if any
  130.                          * time-critical services are currently running!
  131.                          */
  132.  
  133.                     if(ContextID == CONTEXT_TRANSFER || ContextID == CONTEXT_DIAL)
  134.                     {
  135.                         DisplayBeep(Window->WScreen);
  136.  
  137.                         return(FALSE);
  138.                     }
  139.                     else
  140.                     {
  141.                         UBYTE DummyBuffer[MAX_FILENAME_LENGTH];
  142.                         struct FileRequester *FileRequest;
  143.  
  144.                             /* Provide a default name if necessary. */
  145.  
  146.                         if(!Config->PathConfig->HelpFile[0])
  147.                             strcpy(Config->PathConfig->HelpFile,"PROGDIR:term.guide");
  148.  
  149.                             /* Block the windows. */
  150.  
  151.                         BlockWindows();
  152.  
  153.                             /* Get file and path name. */
  154.  
  155.                         LimitedStrcpy(sizeof(DummyBuffer),DummyBuffer,Config->PathConfig->HelpFile);
  156.  
  157.                             /* Get the help text file name. */
  158.  
  159.                         if(FileRequest = OpenSingleFile(Window,LocaleString(MSG_PATHPANEL_SELECT_HELP_FILE_TXT),LocaleString(MSG_GLOBAL_SELECT_TXT),NULL,DummyBuffer,sizeof(DummyBuffer)))
  160.                         {
  161.                             FreeAslRequest(FileRequest);
  162.  
  163.                             if(GetFileSize(DummyBuffer))
  164.                             {
  165.                                 LimitedStrcpy(sizeof(Config->PathConfig->HelpFile),Config->PathConfig->HelpFile,DummyBuffer);
  166.                                 IsValidFile = TRUE;
  167.                             }
  168.                         }
  169.  
  170.                             /* Release the windows... */
  171.  
  172.                         ReleaseWindows();
  173.                     }
  174.                 }
  175.  
  176.                     /* Do we finally have a valid file name? */
  177.  
  178.                 if(IsValidFile)
  179.                 {
  180.                     STATIC LONG NodeTable[] =
  181.                     {
  182.                         MSG_TERMAMIGAGUIDE_NODE_00_TXT,
  183.                         MSG_TERMAMIGAGUIDE_NODE_01_TXT,
  184.                         MSG_TERMAMIGAGUIDE_NODE_02_TXT,
  185.                         MSG_TERMAMIGAGUIDE_NODE_03_TXT,
  186.                         MSG_TERMAMIGAGUIDE_NODE_04_TXT,
  187.                         MSG_TERMAMIGAGUIDE_NODE_05_TXT,
  188.                         MSG_TERMAMIGAGUIDE_NODE_06_TXT,
  189.                         MSG_TERMAMIGAGUIDE_NODE_07_TXT,
  190.                         MSG_TERMAMIGAGUIDE_NODE_08_TXT,
  191.                         MSG_TERMAMIGAGUIDE_NODE_09_TXT,
  192.                         MSG_TERMAMIGAGUIDE_NODE_10_TXT,
  193.                         MSG_TERMAMIGAGUIDE_NODE_11_TXT,
  194.                         MSG_TERMAMIGAGUIDE_NODE_12_TXT,
  195.                         MSG_TERMAMIGAGUIDE_NODE_13_TXT,
  196.                         MSG_TERMAMIGAGUIDE_NODE_14_TXT,
  197.                         MSG_TERMAMIGAGUIDE_NODE_15_TXT,
  198.                         MSG_TERMAMIGAGUIDE_NODE_16_TXT,
  199.                         MSG_TERMAMIGAGUIDE_NODE_17_TXT,
  200.                         MSG_TERMAMIGAGUIDE_NODE_18_TXT,
  201.                         MSG_TERMAMIGAGUIDE_NODE_19_TXT,
  202.                         MSG_TERMAMIGAGUIDE_NODE_20_TXT,
  203.                         MSG_TERMAMIGAGUIDE_NODE_21_TXT,
  204.                         MSG_TERMAMIGAGUIDE_NODE_22_TXT,
  205.                         MSG_TERMAMIGAGUIDE_NODE_23_TXT,
  206.                         MSG_TERMAMIGAGUIDE_NODE_24_TXT,
  207.                         MSG_TERMAMIGAGUIDE_NODE_25_TXT,
  208.                         MSG_TERMAMIGAGUIDE_NODE_26_TXT,
  209.                         MSG_TERMAMIGAGUIDE_NODE_27_TXT,
  210.                         MSG_TERMAMIGAGUIDE_NODE_28_TXT,
  211.                         MSG_TERMAMIGAGUIDE_NODE_29_TXT,
  212.                         MSG_TERMAMIGAGUIDE_NODE_30_TXT,
  213.                         MSG_TERMAMIGAGUIDE_NODE_31_TXT,
  214.                         MSG_TERMAMIGAGUIDE_NODE_32_TXT,
  215.                         MSG_TERMAMIGAGUIDE_NODE_33_TXT,
  216.                         MSG_TERMAMIGAGUIDE_NODE_34_TXT,
  217.                         MSG_TERMAMIGAGUIDE_NODE_35_TXT,
  218.                         MSG_TERMAMIGAGUIDE_NODE_36_TXT,
  219.                         MSG_TERMAMIGAGUIDE_NODE_37_TXT,
  220.                         MSG_TERMAMIGAGUIDE_NODE_38_TXT,
  221.                         MSG_TERMAMIGAGUIDE_NODE_39_TXT,
  222.                         MSG_TERMAMIGAGUIDE_NODE_40_TXT,
  223.                         MSG_TERMAMIGAGUIDE_NODE_41_TXT,
  224.                         MSG_TERMAMIGAGUIDE_NODE_42_TXT,
  225.                         MSG_TERMAMIGAGUIDE_NODE_43_TXT,
  226.                         MSG_TERMAMIGAGUIDE_NODE_44_TXT,
  227.                         MSG_TERMAMIGAGUIDE_NODE_45_TXT,
  228.                         MSG_TERMAMIGAGUIDE_NODE_46_TXT,
  229.                         MSG_TERMAMIGAGUIDE_NODE_47_TXT,
  230.                         MSG_TERMAMIGAGUIDE_NODE_48_TXT,
  231.                         MSG_TERMAMIGAGUIDE_NODE_49_TXT,
  232.                         MSG_TERMAMIGAGUIDE_NODE_50_TXT,
  233.                         MSG_TERMAMIGAGUIDE_NODE_51_TXT,
  234.                         MSG_TERMAMIGAGUIDE_NODE_52_TXT,
  235.                         MSG_TERMAMIGAGUIDE_NODE_53_TXT,
  236.  
  237.                         -1
  238.                     };
  239.  
  240.                         /* Provide the context node names (note: language
  241.                          * specific!).
  242.                          */
  243.  
  244.                     LocalizeStringTable(ContextList,NodeTable);
  245.  
  246.                         /* Clear the instance. */
  247.  
  248.                     memset(&NewGuide,0,sizeof(struct NewAmigaGuide));
  249.  
  250.                         /* Fill in the structure. */
  251.  
  252.                     NewGuide.nag_BaseName    = "termHelp";
  253.                     NewGuide.nag_Name        = Config->PathConfig->HelpFile;
  254.                     NewGuide.nag_ClientPort    = "TERM_HELP";
  255.                     NewGuide.nag_Context    = ContextList;
  256.                     NewGuide.nag_Screen        = Window->WScreen;
  257.  
  258.                         /* Launch the server process. */
  259.  
  260.                     GuideProcess = StartProcessWaitForHandshake("term AmigaGuide Process",(TASKENTRY)GuideServer,TAG_DONE);
  261.                 }
  262.             }
  263.         }
  264.  
  265.             /* Pop the main screen to the front if necessary. */
  266.  
  267.         if(GuideProcess)
  268.         {
  269.             ScreenToFront(Window->WScreen);
  270.  
  271.             return(TRUE);
  272.         }
  273.         else
  274.         {
  275.             if(AmigaGuideBase)
  276.             {
  277.                 CloseLibrary(AmigaGuideBase);
  278.  
  279.                 AmigaGuideBase = NULL;
  280.             }
  281.  
  282.             DisplayBeep(Window->WScreen);
  283.  
  284.             return(FALSE);
  285.         }
  286.     }
  287.     else
  288.     {
  289.         if(GuideProcess && Window)
  290.         {
  291.             ScreenToFront(Window->WScreen);
  292.  
  293.             return(TRUE);
  294.         }
  295.         else
  296.             return(FALSE);
  297.     }
  298. }
  299.  
  300.     /* GuideCleanup():
  301.      *
  302.      *    Terminate the AmigaGuide server and free the
  303.      *    associated resources.
  304.      */
  305.  
  306. VOID
  307. GuideCleanup()
  308. {
  309.     ShakeHands((struct Task *)GuideProcess,SIG_KILL);
  310.  
  311.     if(AmigaGuideBase)
  312.     {
  313.         CloseLibrary(AmigaGuideBase);
  314.  
  315.         AmigaGuideBase = NULL;
  316.     }
  317. }
  318.  
  319.     /* GuideContext(LONG NewContextID):
  320.      *
  321.      *    Set the global AmigaGuide context.
  322.      */
  323.  
  324. VOID
  325. GuideContext(LONG NewContextID)
  326. {
  327.     GuideContextID = NewContextID;
  328. }
  329.  
  330. ULONG SAVE_DS ASM
  331. GuideSetupHook(REG(a0) struct Hook *UnusedHook,REG(a2) HelpMsg *UnusedHelpMessage,REG(a1) struct IBox *UnusedBounds)
  332. {
  333.     if(GuideLaunch(GuideContextID))
  334.     {
  335.         SetAmigaGuideContext(Context,GuideContextID,TAG_DONE);
  336.         SendAmigaGuideContext(Context,TAG_DONE);
  337.  
  338.         return(TRUE);
  339.     }
  340.     else
  341.         return(FALSE);
  342. }
  343.  
  344.     /* GuideSetup():
  345.      *
  346.      *    Try to display the currently selected AmigaGuide
  347.      *    help text.
  348.      */
  349.  
  350. VOID
  351. GuideSetup()
  352. {
  353.     if(GuideLaunch(GuideContextID))
  354.     {
  355.         SetAmigaGuideContext(Context,GuideContextID,TAG_DONE);
  356.         SendAmigaGuideContext(Context,TAG_DONE);
  357.     }
  358. }
  359.  
  360.     /* GuideDisplay(LONG ContextID):
  361.      *
  362.      *    Try to display an AmigaGuide help text.
  363.      */
  364.  
  365. VOID
  366. GuideDisplay(LONG ContextID)
  367. {
  368.     if(GuideLaunch(ContextID))
  369.     {
  370.         SetAmigaGuideContext(Context,ContextID,TAG_DONE);
  371.         SendAmigaGuideContext(Context,TAG_DONE);
  372.     }
  373. }
  374.